/*
 * @Author: Await
 * @Date: 2025-05-10 15:30:00
 * @LastEditors: Await
 * @LastEditTime: 2025-05-08 15:49:34
 * @Description: 雷达图组件
 */

import React, { useEffect, useState } from 'react';
import { Alert } from 'antd';
import ChartBase from '../ChartBase/index';
import { ChartBaseProps } from '../ChartBase/types';

interface RadarChartProps extends ChartBaseProps {
  showEmptyDataWarning?: boolean;
}

/**
 * 雷达图组件
 * 雷达图需要特定的radar配置和数据结构
 */
const RadarChart: React.FC<RadarChartProps> = ({
  option,
  data,
  dataConfig,
  showEmptyDataWarning = true,
  ...restProps
}) => {
  const [isDataValid, setIsDataValid] = useState<boolean>(true);
  const [errorMsg, setErrorMsg] = useState<string>('');

  console.log('RadarChart渲染 - 接收配置:', option);

  // 验证数据对雷达图的有效性
  useEffect(() => {
    if (!data || data.length === 0) {
      setIsDataValid(false);
      setErrorMsg('雷达图需要有效的数据');
      return;
    }

    // 其他验证逻辑可以在这里添加
    setIsDataValid(true);
    setErrorMsg('');
  }, [data]);

  // 确保我们总是有正确且安全的雷达图配置
  // 重点是保证series[0].type = 'radar'
  const radarOption = {
    // 这一行很重要，首先合并用户配置
    ...option,
    // 覆盖type为undefined或空字符串，确保不存在顶层type属性
    type: undefined,

    // 最关键: 确保系列配置存在且类型正确
    series: [
      {
        type: 'radar',  // 固定类型为'radar'，这是最重要的
        name: '雷达图',
        // 如果存在用户指定的系列属性，则合并
        ...(option?.series?.[0] || {})
      }
    ],

    // 确保有默认的radar配置
    radar: {
      // 雷达图的指示器，用来指定雷达图中的多个变量（维度）
      indicator: [
        { name: '指标1', max: 100 },
        { name: '指标2', max: 100 },
        { name: '指标3', max: 100 },
        { name: '指标4', max: 100 },
        { name: '指标5', max: 100 }
      ],
      // 雷达图的形状，可选值：'polygon'（多边形）和'circle'（圆形）
      shape: 'polygon',
      // 雷达图的中心点
      center: ['50%', '50%'],
      // 雷达图的半径
      radius: '75%',
      // 合并用户雷达图配置
      ...(option?.radar || {})
    }
  };

  console.log('RadarChart - 处理后配置:', JSON.stringify({
    hasSeries: !!radarOption.series,
    seriesType: radarOption.series?.[0]?.type,
    hasRadar: !!radarOption.radar
  }));

  // 准备雷达图的默认示例数据
  const defaultRadarData = [
    {
      name: '',
      value: [0, 0, 0, 0, 0]
    }
  ];

  // 数据格式转换：将多种可能的数据格式转换为雷达图所需的格式
  const transformDataForRadar = (inputData: any[]): any[] => {
    if (!inputData || inputData.length === 0) return [];

    console.log('转换雷达图数据:', inputData);

    // 检查数据是否已经是雷达图格式 (每项具有name和数组类型的value)
    const isCorrectFormat = inputData.every(item =>
      item.name && Array.isArray(item.value)
    );

    if (isCorrectFormat) {
      console.log('数据已经是雷达图格式，无需转换');
      return inputData;
    }

    // 检测是否为用户提供的系列数据格式（包含type和data的对象数组）
    const isSeriesFormat = inputData.length > 0 &&
      inputData[0].hasOwnProperty('type') &&
      inputData[0].hasOwnProperty('data') &&
      Array.isArray(inputData[0].data);

    if (isSeriesFormat) {
      console.log('检测到系列数据格式，转换为雷达图格式');

      // 获取第一个系列的数据
      const series = inputData[0];
      const seriesName = series.name || '系列1';
      const seriesData = series.data;

      // 检查seriesData是否符合预期格式（每项都有name和value属性）
      const isValidSeriesData = seriesData.length > 0 &&
        seriesData.every(item => item.hasOwnProperty('name') && item.hasOwnProperty('value'));

      if (isValidSeriesData) {
        // 从系列数据中提取类别名和值
        const categories = seriesData.map((item: any) => item.name);
        const values = seriesData.map((item: any) => item.value);

        console.log('从系列数据提取类别和值:', categories, values);

        // 创建雷达图数据系列，并附加额外的类别信息
        return [{
          name: seriesName,
          value: values,
          // 存储类别信息，供后续配置使用
          _categories: categories
        }];
      }
    }

    // 检测是否为柱状图/饼图格式数据 (每项是{name, value}，但value不是数组)
    const isBarOrPieFormat = inputData.every((item: any) =>
      item.name !== undefined && item.value !== undefined && !Array.isArray(item.value)
    );

    if (isBarOrPieFormat) {
      console.log('检测到柱状图/饼图格式数据，转换为雷达图格式');

      // 从数据项中提取所有类别作为雷达图的指标
      const categories = inputData.map(item => item.name);
      const values = inputData.map(item => item.value);

      // 创建一个雷达图数据系列，包含所有类别的值
      return [{
        name: '系列1',
        value: values,
        // 存储类别信息，供后续配置使用
        _categories: categories
      }];
    }

    // 其他格式尝试处理
    console.log('尝试处理其他数据格式');

    // 尝试检测是否每个数据项中包含相同的字段集合
    if (inputData.length > 0) {
      const firstItem = inputData[0];
      const fields = Object.keys(firstItem).filter(key =>
        key !== 'name' && key !== 'id' && key !== 'key'
      );

      if (fields.length > 0) {
        console.log('从数据字段创建雷达图数据:', fields);

        // 为每个数据项创建一个系列
        return inputData.map(item => {
          const name = item.name || item.category || '未命名系列';
          const value = fields.map(field => item[field] || 0);

          return { name, value };
        });
      }
    }

    // 如果无法转换，返回空数据
    console.log('无法识别数据格式，返回空数据');
    return [];
  };

  // 确保indicator长度与value数组长度匹配
  const checkAndAdjustConfig = (opt: any, d: any[]) => {
    if (!opt || !d || d.length === 0) return opt;

    // 处理带有_categories属性的特殊数据
    if (d.length > 0 && d[0]._categories && Array.isArray(d[0]._categories)) {
      console.log('处理带有类别信息的雷达图数据');

      const categories = d[0]._categories;
      const values = d[0].value;

      // 更新雷达图指标配置
      if (opt.radar) {
        opt.radar.indicator = categories.map((cat: string, idx: number) => {
          // 获取对应的值
          const value = values[idx] || 0;

          return {
            name: cat,
            max: Math.ceil(value * 1.2) || 100 // 设置为数据值的1.2倍
          };
        });

        console.log('更新雷达图指标:', opt.radar.indicator);
      }

      // 清除临时属性，避免干扰
      const cleanData = { ...d[0] };
      delete cleanData._categories;

      // 更新数据数组
      d[0] = cleanData;
    }

    // 创建雷达图指标
    if (opt.radar) {
      // 处理两种情况：1. 数据是标准雷达图格式  2. 数据是转换后的格式

      // 如果至少有一个数据项有数组类型的value，说明可能是雷达图格式
      const hasArrayValues = d.some(item => Array.isArray(item.value));

      if (hasArrayValues) {
        console.log('按雷达图格式处理数据');
        // 找到第一个具有数组value的数据项
        const firstValidItem = d.find(item => Array.isArray(item.value));

        if (firstValidItem && opt.radar) {
          const indicatorCount = opt.radar.indicator?.length || 0;
          const valueCount = firstValidItem.value.length;

          console.log(`检查指标数量: 当前=${indicatorCount}, 需要=${valueCount}`);

          // 确保雷达图有indicator配置
          if (!opt.radar.indicator || !Array.isArray(opt.radar.indicator)) {
            opt.radar.indicator = [];
          }

          // 调整indicator数量
          if (indicatorCount !== valueCount) {
            console.log(`调整雷达图指标数量: ${indicatorCount} -> ${valueCount}`);

            // 如果indicator少于value，添加新指标
            if (indicatorCount < valueCount) {
              for (let i = indicatorCount; i < valueCount; i++) {
                opt.radar.indicator.push({
                  name: `指标${i + 1}`,
                  max: 100
                });
              }
            }
            // 如果indicator多于value，截断indicator
            else if (indicatorCount > valueCount && indicatorCount > 0) {
              opt.radar.indicator = opt.radar.indicator.slice(0, valueCount);
            }
          }

          // 从数据中提取指标名称（如果有的话）
          const categoryData = d.find(item => !Array.isArray(item.value));
          if (categoryData) {
            // 尝试从分类数据中获取指标名称
            opt.radar.indicator.forEach((ind: any, idx: number) => {
              if (idx < valueCount) {
                // 获取第idx个指标对应的名称
                const keys = Object.keys(categoryData).filter(k =>
                  k !== 'name' && k !== 'id' && k !== 'key' && k !== 'value'
                );
                if (keys.length > idx) {
                  ind.name = keys[idx];
                }
              }
            });
          }

          // 更新指标最大值，根据数据自动计算
          opt.radar.indicator.forEach((ind: any, idx: number) => {
            if (idx < valueCount) {
              try {
                // 计算这个指标所有系列的最大值
                const maxValue = Math.max(
                  ...d.filter(item => Array.isArray(item.value))
                    .map(item => Number(item.value[idx] || 0))
                    .filter(v => !isNaN(v) && isFinite(v))
                );
                // 设置最大值，为数据最大值的1.2倍，确保有足够空间
                ind.max = Math.ceil(maxValue * 1.2) || 100;
              } catch (error) {
                console.error('计算指标最大值时出错:', error);
                ind.max = 100; // 设置默认值
              }
            }
          });
        }
      } else {
        // 处理非雷达图格式数据
        console.log('处理非雷达图格式数据');

        // 尝试获取所有可能的指标名称
        const categories = d.map(item => item.name || '').filter(Boolean);

        if (categories.length > 0) {
          console.log('使用数据项名称作为雷达图指标:', categories);

          // 创建一个新的indicator数组
          opt.radar.indicator = categories.map(cat => ({
            name: cat,
            max: 100
          }));

          // 更新指标最大值
          opt.radar.indicator.forEach((ind: any, idx: number) => {
            const item = d.find(item => item.name === ind.name);
            if (item && typeof item.value === 'number') {
              ind.max = Math.ceil(item.value * 1.2) || 100;
            }
          });
        }
      }
    }

    // 确保series[0]具有正确的类型和数据格式
    if (!opt.series || !Array.isArray(opt.series) || opt.series.length === 0) {
      opt.series = [{
        type: 'radar',
        data: d
      }];
    } else {
      opt.series[0] = {
        ...opt.series[0],
        type: 'radar',
        data: d
      };
    }

    // 确保删除top-level类型
    delete opt.type;

    return opt;
  };

  // 如果没有数据或数据无效，使用默认示例数据
  // 在这一步进行数据格式的转换，确保符合雷达图要求
  const processedData = (!data || data.length === 0)
    ? defaultRadarData
    : transformDataForRadar(data);

  console.log('雷达图处理后的数据:', processedData);
  const finalData = processedData;

  // 如果没有数据映射配置，提供默认配置
  const finalDataConfig = dataConfig || {
    dimensions: [
      { field: 'name', name: '名称' }
    ],
    measures: [
      { field: 'value', name: '值', primary: true }
    ]
  };

  // 处理最终配置，确保指标与数据匹配
  const finalRadarOption = checkAndAdjustConfig(radarOption, finalData);

  // 在传递给ChartBase前进行最终检查，确保系列类型正确
  if (finalRadarOption.series?.[0]) {
    finalRadarOption.series[0].type = 'radar';
  }

  // 删除顶层type，避免冲突
  if (finalRadarOption.type !== undefined) {
    console.log('删除雷达图顶层type:', finalRadarOption.type);
    delete finalRadarOption.type;
  }

  // 最终检查日志
  console.log('RadarChart - 最终配置:', JSON.stringify({
    seriesCount: finalRadarOption.series?.length || 0,
    seriesType: finalRadarOption.series?.[0]?.type,
    hasRadar: !!finalRadarOption.radar,
    topLevelType: finalRadarOption.type
  }));

  return (
    <div className="radar-chart-container">
      {!isDataValid && showEmptyDataWarning && (
        <Alert
          message="数据警告"
          description={errorMsg || "雷达图数据不完整或无效，将使用空数据进行渲染。"}
          type="warning"
          showIcon
          style={{ marginBottom: 16 }}
        />
      )}

      <ChartBase
        option={finalRadarOption}
        data={finalData}
        dataConfig={finalDataConfig}
        {...restProps}
      />
    </div>
  );
};

export default RadarChart;